#include "custom_handle.h"
#include <sys/types.h>
#include <sys/wait.h>
#include <ctype.h>
#include <string.h>
#include <sys/socket.h>
#include <math.h>

extern int *p;  // 声明共享内存指针，假设p在其他文件中定义

// 移除 static 修饰符，与头文件声明保持一致
char* init_shared_memory(void) 
{
    struct shm_param para;  
    if (shm_init(&para, "shm", 1024) < 0) 
    {
        printf("shm init err\n");
        return NULL;
    }
    p = (int*)shm_getaddr(&para);  
    if (p == NULL) 
    {
        printf("shm get addr err\n");
        return NULL;
    }  
    return (char*)p;  
}

// 处理登录请求
static int handle_login(int sock, const char *input)
{
    char reply_buf[1024] = {0};
    char *uname = strstr(input, "username=");
    if (uname) uname += strlen("username=");
    char *p_end = strstr(input, "password");
    if (p_end && uname) {
        *(p_end - 1) = '\0';
        printf("username = %s\n", uname);
    }

    char *passwd = NULL;
    if (p_end) {
        passwd = p_end + strlen("password=");
        printf("passwd = %s\n", passwd);
    }

    if (uname && passwd && strcmp(uname, "admin")==0 && strcmp(passwd, "admin")==0)
    {
        sprintf(reply_buf, "<script>localStorage.setItem('usr_user_name', '%s');</script>", uname);
        strcat(reply_buf, "<script>window.location.href = '/index.html';</script>");
        send(sock,reply_buf,strlen(reply_buf),0);
    }
    else
    {
        printf("web login failed\n");

        //"用户名或密码错误"提示
        char out[128] = {0xd3,0xc3,0xbb,0xa7,0xc3,0xfb,0xbb,0xf2,0xc3,0xdc,0xc2,0xeb,0xb4,0xed,0xce,0xf3};
        sprintf(reply_buf, "<script charset='gb2312'>alert('%s');</script>", out);
        strcat(reply_buf, "<script>window.location.href = '/login.html';</script>");
        send(sock,reply_buf,strlen(reply_buf),0);
    }
    return 0;
}

// 处理获取数据请求
static int handle_get_data(int sock)
{
    // 创建根对象 
    cJSON *root = cJSON_CreateObject();
    if (!root) {
        const char* error_response = "{\"status\":\"error\",\"message\":\"内存不足\"}";
        send(sock, error_response, strlen(error_response), 0);
        return -1;
    }
    
    // 添加状态信息
    cJSON_AddStringToObject(root, "status", "ok");
    
    // 创建 "data" 数组
    cJSON *array = cJSON_CreateArray();
    cJSON_AddItemToObject(root, "data", array);
    printf("----------------------%d\n", __LINE__);
    // 打印共享内存信息用于调试
    printf("共享内存指针: 0x%p\n", (void*)p);
    printf("设备数量: %d\n", *p);
    
    // 验证设备数量是否合理
    if (*p < 0 || *p > 1000) { // 设置一个合理的上限，防止越界
        printf("警告: 共享内存中的设备数量异常: %d\n", *p);
        cJSON_Delete(root);
        const char* error_response = "{\"status\":\"error\",\"message\":\"内部数据错误\"}";
        send(sock, error_response, strlen(error_response), 0);
        return -1;
    }
    printf("----------------------%d\n", __LINE__);
    // 从共享内存读取设备数据
    struct std_node *st = (struct std_node *)(p + 1);
    for(int i = 0; i < *p; i++)
    {
        printf("处理设备 #%d: 地址=0x%p\n", i, (void*)st);
        
        cJSON *item = cJSON_CreateObject();
        if (!item) {
            printf("警告: 创建JSON对象失败，跳过设备 #%d\n", i);
            continue;
        }
        
        // 添加设备ID
        cJSON_AddNumberToObject(item, "key", st->key);
        
        // 根据数据类型添加不同的值
        printf("设备 #%d 类型: %d\n", i, st->type);
        
        switch(st->type) 
        {
            case 1: // 布尔值
                cJSON_AddBoolToObject(item, "val", st->new_val.b_val);
                break;
            case 2: // 整数值
                cJSON_AddNumberToObject(item, "val", st->new_val.i_val);
                break;
            case 3: // 浮点数值
                cJSON_AddNumberToObject(item, "val", st->new_val.f_val);
                break;
            default:
                printf("警告: 未知设备类型 %d，设备 #%d\n", st->type, i);
                cJSON_AddStringToObject(item, "val", "unknown");
                break;
        }
        
        cJSON_AddItemToArray(array, item);
        st++;
    }
    
    // 生成JSON字符串并发送
    char *json = cJSON_PrintUnformatted(root);
    if (json) {
        send(sock, json, strlen(json), 0);
        free(json);
    }
    
    cJSON_Delete(root);
    return 0;
}

// 处理设置数据请求
int handle_set_data(int sock, cJSON *data) 
{
    printf("----------------------%d\n", __LINE__);
    // 验证 data 对象包含必要的字段
    cJSON *key = cJSON_GetObjectItem(data, "key");
    cJSON *val = cJSON_GetObjectItem(data, "val");
    
    if (!key || !cJSON_IsNumber(key) || !val) {
        const char* error_response = "{\"status\":\"error\",\"message\":\"缺少 key 或 val 字段\"}";
        send(sock, error_response, strlen(error_response), 0);
        return -1;
    }
    
    int device_key = key->valueint;
    int device_val = val->valueint;
    printf("device_key:%d",device_key);
    printf("device_val:%d",device_val);
    // 查找对应的设备节点
    struct std_node *st = (struct std_node *)(p + 1);
    int found = 0;
     printf("----------------------%d\n", __LINE__);
     printf("%d\n",*(int *)p);
    for(int i = 0; i < *p; i++)
    {
               printf("----------------------%d\n", __LINE__);
        if(st->key == device_key)
        {
            printf("----------------------%d\n", __LINE__);
            // 更新设备状态
            struct control msg;
            msg.type = st->dev_type;
            msg.key = device_key;
            msg.val.b_val = device_val;           
            // 发送到消息队列
            if (msg_queue_send("control", &msg, sizeof(msg), 0) < 0) {
                const char* error_response = "{\"status\":\"error\",\"message\":\"发送控制消息失败\"}";
                send(sock, error_response, strlen(error_response), 0);
                printf("----------------------%d\n", __LINE__);
                return -1;
            }          
            found = 1;
            break;
        }
        st++;
    }
    
    if (!found) {
        const char* error_response = "{\"status\":\"error\",\"message\":\"未找到指定设备\"}";
        send(sock, error_response, strlen(error_response), 0);
        return -1;
    }
    
    // 返回成功响应
    const char *success = "{\"status\":\"ok\"}";
    send(sock, success, strlen(success), 0);
    return 0;
}

// 处理求和请求（需要实现）
static int handle_add(int sock, const char *input)
{
    // 实现求和逻辑
    printf("处理求和请求: %s\n", input);
    
    // 示例：解析 temp 和 data2 参数并返回结果
    char *temp_str = strstr(input, "temp=");
    char *data2_str = strstr(input, "data2=");
    
    if (temp_str && data2_str) {
        temp_str += strlen("temp=");
        data2_str += strlen("data2=");
        
        // 找到参数结束位置
        char *temp_end = strchr(temp_str, '&');
        char *data2_end = strchr(data2_str, '&');
        
        if (temp_end) *temp_end = '\0';
        if (data2_end) *data2_end = '\0';
        
        // 转换为数值并求和
        float temp = atof(temp_str);
        float data2 = atof(data2_str);
        float result = temp + data2;
        
        // 返回结果
        char response[128];
        sprintf(response, "{\"status\":\"ok\",\"result\":%.2f}", result);
        send(sock, response, strlen(response), 0);
        
        return 0;
    }
    
    const char* error_response = "{\"status\":\"error\",\"message\":\"参数格式错误\"}";
    send(sock, error_response, strlen(error_response), 0);
    return -1;
}

/**
 * @brief 处理自定义请求，在这里添加进程通信
 * @param input
 * @return
 */
int parse_and_process(int sock, const char *query_string, const char *input)
{
    //query_string 不一定能用的到

    //先处理登录操作
    if(strstr(input, "username=") && strstr(input, "password="))
    {
        return handle_login(sock, input);
    }
    //处理求和请求
    else if(strstr(input, "temp=") && strstr(input, "data2="))
    {
        return handle_add(sock, input);
    }
    else if (strcmp(query_string, "get_data") == 0)
    {
        return handle_get_data(sock);
    }
    else if (strstr(input, "{\"type\":2,") != NULL) // 处理设置数据请求
    {
        // 解析 JSON 请求
        cJSON *root = cJSON_Parse(input);
        if (!root) {
            printf("JSON 解析失败: %s\n", cJSON_GetErrorPtr());
            const char* error_response = "{\"status\":\"error\",\"message\":\"JSON 格式错误\"}";
            send(sock, error_response, strlen(error_response), 0);
            return -1;
        }
        
        cJSON *data = cJSON_GetObjectItem(root, "data");
        if (!data) {
            printf("缺少 data 字段\n");
            cJSON_Delete(root);
            const char* error_response = "{\"status\":\"error\",\"message\":\"缺少 data 字段\"}";
            send(sock, error_response, strlen(error_response), 0);
            return -1;
        }
        
        int result = handle_set_data(sock, data);
        cJSON_Delete(root);
        return result;
    }
    
    const char* error_response = "{\"status\":\"error\",\"message\":\"未知请求\"}";
    send(sock, error_response, strlen(error_response), 0);
    return -1;
}